/*
 *
 *    Copyright (c) 2022 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

// THIS FILE IS GENERATED BY ZAP
// This file is generated from clusters-Commands.h.zapt

#pragma once

#include <app/data-model/DecodableList.h>
#include <app/data-model/Encode.h>
#include <app/data-model/List.h>
#include <app/data-model/NullObject.h>
#include <app/data-model/Nullable.h>
#include <lib/core/DataModelTypes.h>
#include <lib/core/Optional.h>
#include <lib/core/TLV.h>
#include <lib/support/BitMask.h>

#include <clusters/shared/Enums.h>
#include <clusters/shared/Structs.h>

#include <clusters/UnitTesting/ClusterId.h>
#include <clusters/UnitTesting/CommandIds.h>
#include <clusters/UnitTesting/Enums.h>
#include <clusters/UnitTesting/Structs.h>

#include <cstdint>

namespace chip
{
namespace app
{
	namespace Clusters
	{
		namespace UnitTesting
		{
			namespace Commands
			{
				// Forward-declarations so we can reference these later.

				namespace Test
				{
					struct Type;
					struct DecodableType;
				} // namespace Test

				namespace TestSpecificResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace TestSpecificResponse

				namespace TestNotHandled
				{
					struct Type;
					struct DecodableType;
				} // namespace TestNotHandled

				namespace TestAddArgumentsResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace TestAddArgumentsResponse

				namespace TestSpecific
				{
					struct Type;
					struct DecodableType;
				} // namespace TestSpecific

				namespace TestSimpleArgumentResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace TestSimpleArgumentResponse

				namespace TestUnknownCommand
				{
					struct Type;
					struct DecodableType;
				} // namespace TestUnknownCommand

				namespace TestStructArrayArgumentResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace TestStructArrayArgumentResponse

				namespace TestAddArguments
				{
					struct Type;
					struct DecodableType;
				} // namespace TestAddArguments

				namespace TestListInt8UReverseResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace TestListInt8UReverseResponse

				namespace TestSimpleArgumentRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestSimpleArgumentRequest

				namespace TestEnumsResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace TestEnumsResponse

				namespace TestStructArrayArgumentRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestStructArrayArgumentRequest

				namespace TestNullableOptionalResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace TestNullableOptionalResponse

				namespace TestStructArgumentRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestStructArgumentRequest

				namespace TestComplexNullableOptionalResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace TestComplexNullableOptionalResponse

				namespace TestNestedStructArgumentRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestNestedStructArgumentRequest

				namespace BooleanResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace BooleanResponse

				namespace TestListStructArgumentRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestListStructArgumentRequest

				namespace SimpleStructResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace SimpleStructResponse

				namespace TestListInt8UArgumentRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestListInt8UArgumentRequest

				namespace TestEmitTestEventResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace TestEmitTestEventResponse

				namespace TestNestedStructListArgumentRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestNestedStructListArgumentRequest

				namespace TestEmitTestFabricScopedEventResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace TestEmitTestFabricScopedEventResponse

				namespace TestListNestedStructListArgumentRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestListNestedStructListArgumentRequest

				namespace TestBatchHelperResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace TestBatchHelperResponse

				namespace TestListInt8UReverseRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestListInt8UReverseRequest

				namespace StringEchoResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace StringEchoResponse

				namespace TestEnumsRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestEnumsRequest

				namespace GlobalEchoResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace GlobalEchoResponse

				namespace TestNullableOptionalRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestNullableOptionalRequest

				namespace TestComplexNullableOptionalRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestComplexNullableOptionalRequest

				namespace SimpleStructEchoRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace SimpleStructEchoRequest

				namespace TimedInvokeRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TimedInvokeRequest

				namespace TestSimpleOptionalArgumentRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestSimpleOptionalArgumentRequest

				namespace TestEmitTestEventRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestEmitTestEventRequest

				namespace TestEmitTestFabricScopedEventRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestEmitTestFabricScopedEventRequest

				namespace TestBatchHelperRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestBatchHelperRequest

				namespace TestSecondBatchHelperRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestSecondBatchHelperRequest

				namespace StringEchoRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace StringEchoRequest

				namespace GlobalEchoRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace GlobalEchoRequest

				namespace TestCheckCommandFlags
				{
					struct Type;
					struct DecodableType;
				} // namespace TestCheckCommandFlags

				namespace TestDifferentVendorMeiRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace TestDifferentVendorMeiRequest

				namespace TestDifferentVendorMeiResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace TestDifferentVendorMeiResponse

			} // namespace Commands

			namespace Commands
			{
				namespace Test
				{
					enum class Fields : uint8_t {};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId() { return Commands::Test::Id; }
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId() { return Commands::Test::Id; }
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace Test
				namespace TestSpecificResponse
				{
					enum class Fields : uint8_t {
						kReturnValue = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestSpecificResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						uint8_t returnValue = static_cast<uint8_t>(0);

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestSpecificResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						uint8_t returnValue = static_cast<uint8_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestSpecificResponse
				namespace TestNotHandled
				{
					enum class Fields : uint8_t {};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestNotHandled::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestNotHandled::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestNotHandled
				namespace TestAddArgumentsResponse
				{
					enum class Fields : uint8_t {
						kReturnValue = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestAddArgumentsResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						uint8_t returnValue = static_cast<uint8_t>(0);

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestAddArgumentsResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						uint8_t returnValue = static_cast<uint8_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestAddArgumentsResponse
				namespace TestSpecific
				{
					enum class Fields : uint8_t {};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestSpecific::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::UnitTesting::Commands::
							TestSpecificResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestSpecific::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestSpecific
				namespace TestSimpleArgumentResponse
				{
					enum class Fields : uint8_t {
						kReturnValue = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestSimpleArgumentResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						bool returnValue = static_cast<bool>(0);

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestSimpleArgumentResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						bool returnValue = static_cast<bool>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestSimpleArgumentResponse
				namespace TestUnknownCommand
				{
					enum class Fields : uint8_t {};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestUnknownCommand::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestUnknownCommand::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestUnknownCommand
				namespace TestStructArrayArgumentResponse
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
						kArg2 = 1,
						kArg3 = 2,
						kArg4 = 3,
						kArg5 = 4,
						kArg6 = 5,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestStructArrayArgumentResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						DataModel::List<const Structs::NestedStructList::Type> arg1;
						DataModel::List<const Structs::SimpleStruct::Type> arg2;
						DataModel::List<const SimpleEnum> arg3;
						DataModel::List<const bool> arg4;
						SimpleEnum arg5 = static_cast<SimpleEnum>(0);
						bool arg6 = static_cast<bool>(0);

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestStructArrayArgumentResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						DataModel::DecodableList<Structs::NestedStructList::DecodableType> arg1;
						DataModel::DecodableList<Structs::SimpleStruct::DecodableType> arg2;
						DataModel::DecodableList<SimpleEnum> arg3;
						DataModel::DecodableList<bool> arg4;
						SimpleEnum arg5 = static_cast<SimpleEnum>(0);
						bool arg6 = static_cast<bool>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestStructArrayArgumentResponse
				namespace TestAddArguments
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
						kArg2 = 1,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestAddArguments::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						uint8_t arg1 = static_cast<uint8_t>(0);
						uint8_t arg2 = static_cast<uint8_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::UnitTesting::Commands::
							TestAddArgumentsResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestAddArguments::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t arg1 = static_cast<uint8_t>(0);
						uint8_t arg2 = static_cast<uint8_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestAddArguments
				namespace TestListInt8UReverseResponse
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestListInt8UReverseResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						DataModel::List<const uint8_t> arg1;

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestListInt8UReverseResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						DataModel::DecodableList<uint8_t> arg1;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestListInt8UReverseResponse
				namespace TestSimpleArgumentRequest
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestSimpleArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						bool arg1 = static_cast<bool>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::UnitTesting::Commands::
							TestSimpleArgumentResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestSimpleArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						bool arg1 = static_cast<bool>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestSimpleArgumentRequest
				namespace TestEnumsResponse
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
						kArg2 = 1,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestEnumsResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						chip::VendorId arg1 = static_cast<chip::VendorId>(0);
						SimpleEnum arg2 = static_cast<SimpleEnum>(0);

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestEnumsResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						chip::VendorId arg1 = static_cast<chip::VendorId>(0);
						SimpleEnum arg2 = static_cast<SimpleEnum>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestEnumsResponse
				namespace TestStructArrayArgumentRequest
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
						kArg2 = 1,
						kArg3 = 2,
						kArg4 = 3,
						kArg5 = 4,
						kArg6 = 5,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestStructArrayArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						DataModel::List<const Structs::NestedStructList::Type> arg1;
						DataModel::List<const Structs::SimpleStruct::Type> arg2;
						DataModel::List<const SimpleEnum> arg3;
						DataModel::List<const bool> arg4;
						SimpleEnum arg5 = static_cast<SimpleEnum>(0);
						bool arg6 = static_cast<bool>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::UnitTesting::Commands::
							TestStructArrayArgumentResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestStructArrayArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						DataModel::DecodableList<Structs::NestedStructList::DecodableType> arg1;
						DataModel::DecodableList<Structs::SimpleStruct::DecodableType> arg2;
						DataModel::DecodableList<SimpleEnum> arg3;
						DataModel::DecodableList<bool> arg4;
						SimpleEnum arg5 = static_cast<SimpleEnum>(0);
						bool arg6 = static_cast<bool>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestStructArrayArgumentRequest
				namespace TestNullableOptionalResponse
				{
					enum class Fields : uint8_t {
						kWasPresent = 0,
						kWasNull = 1,
						kValue = 2,
						kOriginalValue = 3,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestNullableOptionalResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						bool wasPresent = static_cast<bool>(0);
						Optional<bool> wasNull;
						Optional<uint8_t> value;
						Optional<DataModel::Nullable<uint8_t>> originalValue;

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestNullableOptionalResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						bool wasPresent = static_cast<bool>(0);
						Optional<bool> wasNull;
						Optional<uint8_t> value;
						Optional<DataModel::Nullable<uint8_t>> originalValue;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestNullableOptionalResponse
				namespace TestStructArgumentRequest
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestStructArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						Structs::SimpleStruct::Type arg1;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType =
							Clusters::UnitTesting::Commands::BooleanResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestStructArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						Structs::SimpleStruct::DecodableType arg1;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestStructArgumentRequest
				namespace TestComplexNullableOptionalResponse
				{
					enum class Fields : uint8_t {
						kNullableIntWasNull = 0,
						kNullableIntValue = 1,
						kOptionalIntWasPresent = 2,
						kOptionalIntValue = 3,
						kNullableOptionalIntWasPresent = 4,
						kNullableOptionalIntWasNull = 5,
						kNullableOptionalIntValue = 6,
						kNullableStringWasNull = 7,
						kNullableStringValue = 8,
						kOptionalStringWasPresent = 9,
						kOptionalStringValue = 10,
						kNullableOptionalStringWasPresent = 11,
						kNullableOptionalStringWasNull = 12,
						kNullableOptionalStringValue = 13,
						kNullableStructWasNull = 14,
						kNullableStructValue = 15,
						kOptionalStructWasPresent = 16,
						kOptionalStructValue = 17,
						kNullableOptionalStructWasPresent = 18,
						kNullableOptionalStructWasNull = 19,
						kNullableOptionalStructValue = 20,
						kNullableListWasNull = 21,
						kNullableListValue = 22,
						kOptionalListWasPresent = 23,
						kOptionalListValue = 24,
						kNullableOptionalListWasPresent = 25,
						kNullableOptionalListWasNull = 26,
						kNullableOptionalListValue = 27,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestComplexNullableOptionalResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						bool nullableIntWasNull = static_cast<bool>(0);
						Optional<uint16_t> nullableIntValue;
						bool optionalIntWasPresent = static_cast<bool>(0);
						Optional<uint16_t> optionalIntValue;
						bool nullableOptionalIntWasPresent = static_cast<bool>(0);
						Optional<bool> nullableOptionalIntWasNull;
						Optional<uint16_t> nullableOptionalIntValue;
						bool nullableStringWasNull = static_cast<bool>(0);
						Optional<chip::CharSpan> nullableStringValue;
						bool optionalStringWasPresent = static_cast<bool>(0);
						Optional<chip::CharSpan> optionalStringValue;
						bool nullableOptionalStringWasPresent = static_cast<bool>(0);
						Optional<bool> nullableOptionalStringWasNull;
						Optional<chip::CharSpan> nullableOptionalStringValue;
						bool nullableStructWasNull = static_cast<bool>(0);
						Optional<Structs::SimpleStruct::Type> nullableStructValue;
						bool optionalStructWasPresent = static_cast<bool>(0);
						Optional<Structs::SimpleStruct::Type> optionalStructValue;
						bool nullableOptionalStructWasPresent = static_cast<bool>(0);
						Optional<bool> nullableOptionalStructWasNull;
						Optional<Structs::SimpleStruct::Type> nullableOptionalStructValue;
						bool nullableListWasNull = static_cast<bool>(0);
						Optional<DataModel::List<const SimpleEnum>> nullableListValue;
						bool optionalListWasPresent = static_cast<bool>(0);
						Optional<DataModel::List<const SimpleEnum>> optionalListValue;
						bool nullableOptionalListWasPresent = static_cast<bool>(0);
						Optional<bool> nullableOptionalListWasNull;
						Optional<DataModel::List<const SimpleEnum>> nullableOptionalListValue;

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestComplexNullableOptionalResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						bool nullableIntWasNull = static_cast<bool>(0);
						Optional<uint16_t> nullableIntValue;
						bool optionalIntWasPresent = static_cast<bool>(0);
						Optional<uint16_t> optionalIntValue;
						bool nullableOptionalIntWasPresent = static_cast<bool>(0);
						Optional<bool> nullableOptionalIntWasNull;
						Optional<uint16_t> nullableOptionalIntValue;
						bool nullableStringWasNull = static_cast<bool>(0);
						Optional<chip::CharSpan> nullableStringValue;
						bool optionalStringWasPresent = static_cast<bool>(0);
						Optional<chip::CharSpan> optionalStringValue;
						bool nullableOptionalStringWasPresent = static_cast<bool>(0);
						Optional<bool> nullableOptionalStringWasNull;
						Optional<chip::CharSpan> nullableOptionalStringValue;
						bool nullableStructWasNull = static_cast<bool>(0);
						Optional<Structs::SimpleStruct::DecodableType> nullableStructValue;
						bool optionalStructWasPresent = static_cast<bool>(0);
						Optional<Structs::SimpleStruct::DecodableType> optionalStructValue;
						bool nullableOptionalStructWasPresent = static_cast<bool>(0);
						Optional<bool> nullableOptionalStructWasNull;
						Optional<Structs::SimpleStruct::DecodableType>
							nullableOptionalStructValue;
						bool nullableListWasNull = static_cast<bool>(0);
						Optional<DataModel::DecodableList<SimpleEnum>> nullableListValue;
						bool optionalListWasPresent = static_cast<bool>(0);
						Optional<DataModel::DecodableList<SimpleEnum>> optionalListValue;
						bool nullableOptionalListWasPresent = static_cast<bool>(0);
						Optional<bool> nullableOptionalListWasNull;
						Optional<DataModel::DecodableList<SimpleEnum>> nullableOptionalListValue;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestComplexNullableOptionalResponse
				namespace TestNestedStructArgumentRequest
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestNestedStructArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						Structs::NestedStruct::Type arg1;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType =
							Clusters::UnitTesting::Commands::BooleanResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestNestedStructArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						Structs::NestedStruct::DecodableType arg1;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestNestedStructArgumentRequest
				namespace BooleanResponse
				{
					enum class Fields : uint8_t {
						kValue = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::BooleanResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						bool value = static_cast<bool>(0);

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::BooleanResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						bool value = static_cast<bool>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace BooleanResponse
				namespace TestListStructArgumentRequest
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestListStructArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						DataModel::List<const Structs::SimpleStruct::Type> arg1;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType =
							Clusters::UnitTesting::Commands::BooleanResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestListStructArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						DataModel::DecodableList<Structs::SimpleStruct::DecodableType> arg1;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestListStructArgumentRequest
				namespace SimpleStructResponse
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::SimpleStructResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						Structs::SimpleStruct::Type arg1;

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::SimpleStructResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						Structs::SimpleStruct::DecodableType arg1;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace SimpleStructResponse
				namespace TestListInt8UArgumentRequest
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestListInt8UArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						DataModel::List<const uint8_t> arg1;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType =
							Clusters::UnitTesting::Commands::BooleanResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestListInt8UArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						DataModel::DecodableList<uint8_t> arg1;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestListInt8UArgumentRequest
				namespace TestEmitTestEventResponse
				{
					enum class Fields : uint8_t {
						kValue = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestEmitTestEventResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						uint64_t value = static_cast<uint64_t>(0);

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestEmitTestEventResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						uint64_t value = static_cast<uint64_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestEmitTestEventResponse
				namespace TestNestedStructListArgumentRequest
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestNestedStructListArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						Structs::NestedStructList::Type arg1;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType =
							Clusters::UnitTesting::Commands::BooleanResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestNestedStructListArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						Structs::NestedStructList::DecodableType arg1;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestNestedStructListArgumentRequest
				namespace TestEmitTestFabricScopedEventResponse
				{
					enum class Fields : uint8_t {
						kValue = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestEmitTestFabricScopedEventResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						uint64_t value = static_cast<uint64_t>(0);

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestEmitTestFabricScopedEventResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						uint64_t value = static_cast<uint64_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestEmitTestFabricScopedEventResponse
				namespace TestListNestedStructListArgumentRequest
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestListNestedStructListArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						DataModel::List<const Structs::NestedStructList::Type> arg1;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType =
							Clusters::UnitTesting::Commands::BooleanResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestListNestedStructListArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						DataModel::DecodableList<Structs::NestedStructList::DecodableType> arg1;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestListNestedStructListArgumentRequest
				namespace TestBatchHelperResponse
				{
					enum class Fields : uint8_t {
						kBuffer = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestBatchHelperResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						chip::ByteSpan buffer;

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestBatchHelperResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						chip::ByteSpan buffer;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestBatchHelperResponse
				namespace TestListInt8UReverseRequest
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestListInt8UReverseRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						DataModel::List<const uint8_t> arg1;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::UnitTesting::Commands::
							TestListInt8UReverseResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestListInt8UReverseRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						DataModel::DecodableList<uint8_t> arg1;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestListInt8UReverseRequest
				namespace StringEchoResponse
				{
					enum class Fields : uint8_t {
						kPayload = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::StringEchoResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						chip::ByteSpan payload;

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::StringEchoResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						chip::ByteSpan payload;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace StringEchoResponse
				namespace TestEnumsRequest
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
						kArg2 = 1,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestEnumsRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						chip::VendorId arg1 = static_cast<chip::VendorId>(0);
						SimpleEnum arg2 = static_cast<SimpleEnum>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType =
							Clusters::UnitTesting::Commands::TestEnumsResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestEnumsRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						chip::VendorId arg1 = static_cast<chip::VendorId>(0);
						SimpleEnum arg2 = static_cast<SimpleEnum>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestEnumsRequest
				namespace GlobalEchoResponse
				{
					enum class Fields : uint8_t {
						kField1 = 0,
						kField2 = 1,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::GlobalEchoResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						Globals::Structs::TestGlobalStruct::Type field1;
						Globals::TestGlobalEnum field2 =
							static_cast<Globals::TestGlobalEnum>(0);

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::GlobalEchoResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						Globals::Structs::TestGlobalStruct::DecodableType field1;
						Globals::TestGlobalEnum field2 =
							static_cast<Globals::TestGlobalEnum>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace GlobalEchoResponse
				namespace TestNullableOptionalRequest
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestNullableOptionalRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						Optional<DataModel::Nullable<uint8_t>> arg1;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::UnitTesting::Commands::
							TestNullableOptionalResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestNullableOptionalRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						Optional<DataModel::Nullable<uint8_t>> arg1;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestNullableOptionalRequest
				namespace TestComplexNullableOptionalRequest
				{
					enum class Fields : uint8_t {
						kNullableInt = 0,
						kOptionalInt = 1,
						kNullableOptionalInt = 2,
						kNullableString = 3,
						kOptionalString = 4,
						kNullableOptionalString = 5,
						kNullableStruct = 6,
						kOptionalStruct = 7,
						kNullableOptionalStruct = 8,
						kNullableList = 9,
						kOptionalList = 10,
						kNullableOptionalList = 11,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestComplexNullableOptionalRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						DataModel::Nullable<uint16_t> nullableInt;
						Optional<uint16_t> optionalInt;
						Optional<DataModel::Nullable<uint16_t>> nullableOptionalInt;
						DataModel::Nullable<chip::CharSpan> nullableString;
						Optional<chip::CharSpan> optionalString;
						Optional<DataModel::Nullable<chip::CharSpan>> nullableOptionalString;
						DataModel::Nullable<Structs::SimpleStruct::Type> nullableStruct;
						Optional<Structs::SimpleStruct::Type> optionalStruct;
						Optional<DataModel::Nullable<Structs::SimpleStruct::Type>>
							nullableOptionalStruct;
						DataModel::Nullable<DataModel::List<const SimpleEnum>> nullableList;
						Optional<DataModel::List<const SimpleEnum>> optionalList;
						Optional<DataModel::Nullable<DataModel::List<const SimpleEnum>>>
							nullableOptionalList;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::UnitTesting::Commands::
							TestComplexNullableOptionalResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestComplexNullableOptionalRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						DataModel::Nullable<uint16_t> nullableInt;
						Optional<uint16_t> optionalInt;
						Optional<DataModel::Nullable<uint16_t>> nullableOptionalInt;
						DataModel::Nullable<chip::CharSpan> nullableString;
						Optional<chip::CharSpan> optionalString;
						Optional<DataModel::Nullable<chip::CharSpan>> nullableOptionalString;
						DataModel::Nullable<Structs::SimpleStruct::DecodableType> nullableStruct;
						Optional<Structs::SimpleStruct::DecodableType> optionalStruct;
						Optional<DataModel::Nullable<Structs::SimpleStruct::DecodableType>>
							nullableOptionalStruct;
						DataModel::Nullable<DataModel::DecodableList<SimpleEnum>> nullableList;
						Optional<DataModel::DecodableList<SimpleEnum>> optionalList;
						Optional<DataModel::Nullable<DataModel::DecodableList<SimpleEnum>>>
							nullableOptionalList;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestComplexNullableOptionalRequest
				namespace SimpleStructEchoRequest
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::SimpleStructEchoRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						Structs::SimpleStruct::Type arg1;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::UnitTesting::Commands::
							SimpleStructResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::SimpleStructEchoRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						Structs::SimpleStruct::DecodableType arg1;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace SimpleStructEchoRequest
				namespace TimedInvokeRequest
				{
					enum class Fields : uint8_t {};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TimedInvokeRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return true; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TimedInvokeRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TimedInvokeRequest
				namespace TestSimpleOptionalArgumentRequest
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestSimpleOptionalArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						Optional<bool> arg1;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestSimpleOptionalArgumentRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						Optional<bool> arg1;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestSimpleOptionalArgumentRequest
				namespace TestEmitTestEventRequest
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
						kArg2 = 1,
						kArg3 = 2,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestEmitTestEventRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						uint8_t arg1 = static_cast<uint8_t>(0);
						SimpleEnum arg2 = static_cast<SimpleEnum>(0);
						bool arg3 = static_cast<bool>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::UnitTesting::Commands::
							TestEmitTestEventResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestEmitTestEventRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t arg1 = static_cast<uint8_t>(0);
						SimpleEnum arg2 = static_cast<SimpleEnum>(0);
						bool arg3 = static_cast<bool>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestEmitTestEventRequest
				namespace TestEmitTestFabricScopedEventRequest
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestEmitTestFabricScopedEventRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						uint8_t arg1 = static_cast<uint8_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::UnitTesting::Commands::
							TestEmitTestFabricScopedEventResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestEmitTestFabricScopedEventRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t arg1 = static_cast<uint8_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestEmitTestFabricScopedEventRequest
				namespace TestBatchHelperRequest
				{
					enum class Fields : uint8_t {
						kSleepBeforeResponseTimeMs = 0,
						kSizeOfResponseBuffer = 1,
						kFillCharacter = 2,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestBatchHelperRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						uint16_t sleepBeforeResponseTimeMs = static_cast<uint16_t>(0);
						uint16_t sizeOfResponseBuffer = static_cast<uint16_t>(0);
						uint8_t fillCharacter = static_cast<uint8_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::UnitTesting::Commands::
							TestBatchHelperResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestBatchHelperRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint16_t sleepBeforeResponseTimeMs = static_cast<uint16_t>(0);
						uint16_t sizeOfResponseBuffer = static_cast<uint16_t>(0);
						uint8_t fillCharacter = static_cast<uint8_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestBatchHelperRequest
				namespace TestSecondBatchHelperRequest
				{
					enum class Fields : uint8_t {
						kSleepBeforeResponseTimeMs = 0,
						kSizeOfResponseBuffer = 1,
						kFillCharacter = 2,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestSecondBatchHelperRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						uint16_t sleepBeforeResponseTimeMs = static_cast<uint16_t>(0);
						uint16_t sizeOfResponseBuffer = static_cast<uint16_t>(0);
						uint8_t fillCharacter = static_cast<uint8_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::UnitTesting::Commands::
							TestBatchHelperResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestSecondBatchHelperRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint16_t sleepBeforeResponseTimeMs = static_cast<uint16_t>(0);
						uint16_t sizeOfResponseBuffer = static_cast<uint16_t>(0);
						uint8_t fillCharacter = static_cast<uint8_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestSecondBatchHelperRequest
				namespace StringEchoRequest
				{
					enum class Fields : uint8_t {
						kPayload = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::StringEchoRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						chip::ByteSpan payload;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::UnitTesting::Commands::
							StringEchoResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::StringEchoRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						chip::ByteSpan payload;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace StringEchoRequest
				namespace GlobalEchoRequest
				{
					enum class Fields : uint8_t {
						kField1 = 0,
						kField2 = 1,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::GlobalEchoRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						Globals::Structs::TestGlobalStruct::Type field1;
						Globals::TestGlobalEnum field2 =
							static_cast<Globals::TestGlobalEnum>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::UnitTesting::Commands::
							GlobalEchoResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::GlobalEchoRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						Globals::Structs::TestGlobalStruct::DecodableType field1;
						Globals::TestGlobalEnum field2 =
							static_cast<Globals::TestGlobalEnum>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace GlobalEchoRequest
				namespace TestCheckCommandFlags
				{
					enum class Fields : uint8_t {};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestCheckCommandFlags::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return true; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestCheckCommandFlags::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = true;

						CHIP_ERROR Decode(TLV::TLVReader &reader,
								  FabricIndex aAccessingFabricIndex);
					};
				}; // namespace TestCheckCommandFlags
				namespace TestDifferentVendorMeiRequest
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestDifferentVendorMeiRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						uint8_t arg1 = static_cast<uint8_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::UnitTesting::Commands::
							TestDifferentVendorMeiResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestDifferentVendorMeiRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t arg1 = static_cast<uint8_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestDifferentVendorMeiRequest
				namespace TestDifferentVendorMeiResponse
				{
					enum class Fields : uint8_t {
						kArg1 = 0,
						kEventNumber = 1,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestDifferentVendorMeiResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						uint8_t arg1 = static_cast<uint8_t>(0);
						uint64_t eventNumber = static_cast<uint64_t>(0);

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::TestDifferentVendorMeiResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::UnitTesting::Id;
						}

						uint8_t arg1 = static_cast<uint8_t>(0);
						uint64_t eventNumber = static_cast<uint64_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace TestDifferentVendorMeiResponse
			} // namespace Commands
		} // namespace UnitTesting
	} // namespace Clusters
} // namespace app
} // namespace chip
